import React from 'react';
import {
  Popover, Tooltip
} from 'antd';
import config from 'config';
import httpFetch from 'share/httpFetch';
import errorMessage from 'share/errorMessage';
import { deepFullCopy, messages } from "share/common";
import moment from 'moment';
import RSCService from 'containers/data-center/report/travel-report/report-search-components.service';
import configureStore from 'stores';

import axios from 'axios';

// http响应拦截器
axios.interceptors.response.use(data => {
  let dataAfterTask13509 = fixTask17073(data);
  return dataAfterTask13509
}, error => {
  return Promise.reject(error)
});
// http响应拦截器
axios.interceptors.response.use(data => {
  return fixTask24211(data);
}, error => {
  return Promise.reject(error)
});

/*
* 任务id 24211
* 对接口返回的数据 额外加数据
* */
function fixTask24211(data) {
  if (data.config.url.match('/api/custom/forms/setOfBooks/all') && data.config.data.match('0000') && data.data && data.data.length >= 0) {
    let obj = {};
    obj.formOID = "0000";
    obj.formName = messages('data-center.key84')/*消费商(公司支付)*/;
    data.data.push(obj)
  }
  return data;
}

//账套把币种加上
function fixTask17073(data) {
  if (data.config.url.match('/api/setOfBooks/query/dto') && data.data && data.data.length) {
    data.data.map((item) => {
      item.setOfBooksName_functionalCurrencyCode = item.setOfBooksName + "/" + item.functionalCurrencyCode;
    })
  }
  return data;
}

//查询时间规则：默认是当月：本月1号到目前，最多查询三个月
// 这moment用法？？？
let myDate = new Date();
let currentTime = moment(new Date(myDate.getFullYear(), myDate.getMonth(), myDate.getDate()));
let currentTimeBeforeThree = moment(new Date(myDate.getFullYear(), myDate.getMonth(), 1));  // 这什么命名？？？
// moment() // 当前时间
// moment(new Date(2011, 9, 16)) // 2011-10-16
//为了保证引用传递，不能对数组重新赋值,赋值前清空,用length=0;
//城市列表
let popularCityList = [];
//发票标签
let receiptLabelTypesList = [];
//报销单状态
let invoiceStatusList = [];
//报销单状态 额外加 消费商（公司支付）
let invoiceStatusListAddVendorList = [];
//驳回节点
let rejectCodeList = [];
//单据类型
let invoiceTypeList = [];
//发票类型
let invTypeList = [];
//发票状态
let invStatusList = [];
//发票检验结果
let invCheckResultList = [];
//报销单单据类型
let reimbDocTypeList = [];
//申请单单据类型
let applicationDocTypeList = [];
let applicationDocTypeList2 = [];
//行程类型
let tripTypeList = [];
//申请单状态
let appStatusList = [];
//支付方式列表
let paymentTypeList = [];
//借款单状态
let loanStatusList = [];
//是否合规
let isLowOkList = [];
//商务卡状态
let corpCardStatusList = [];
// 酒店费用报表 订单类型
let hotelOrderTypeList = [];
// 机票费用报表 订单类型
let flightOrderTypeList = [];
// 费用标签列表
let invoiceTagList = [];
//效率报表单据类型
let effInvoiceTypeList = [];
//差旅申请报表新增筛选器-单据名称
let formTypeList = [];
//申请明细报表新增筛选器-单据名称
let formTypeListResuqest = [];
//还款单状态(type=5025)
let repaymentStatusList = [];
//还款方式(type=5026)
let repaymentTypeList = [];
//还款单报表类型
let payeeTypeList = [];
//币种列表
let currencyTypeList = [];
// 单据标签列表
let docLabelsList = [];
// 收单状态列表
let receiptStatusList = [];
/*
 * 搜索组件列表，这个根据后端来显示，\
 * 后端传几个来，前端就显示几个，通过 backend_id 来匹配,这是前后端约定好的
 * backend_id 类型如下
 * 1 date 时间(有默认值，是一个开始时间，结束时间，需校验不能为空，不能夸 12 个月)
 * 2 city 城市
 * 4 source 供应商
 * 5 department 部门
 * 6 books 账套
 * 7 legal 法人
 * 8 app_status 申请单状态
 * 9 reimb_status 状态（报销单状态）
 * 10 invoice 单据类型
 * 11 rejecter 驳回人(人员控件)
 * 12 rejectnode 驳回节点（ok）
 * 13 company,选择公司
 * 14 reimbursement_type 报销单单据类型
 * 15 application_type 申请单单据类型
 * 16 trip 行程类型
 * 17 loan_status 借款单状态
 * 18 source 供应商,前端写死的选择类型
 * 19 inv_type 发票类型
 * 20 inv_status 发票状态
 * 21 inv_check_result 发票检验结果
 * 22 compliant 是否合规
 * 23 corp_card_status 商务卡状态
 * 24 act_nam 刷卡人(人员控件)
 * 成本中心项必须要有账套依赖，如果只有成本中心项，就属于设计错误，报表无法展示
 * 25 cost 成本中心，上传成本中心项OID ，成本中心依赖于账套，后端返回字段的时候，会有一个字段标志依赖关系
 * 26 slave_date 时间（无默认值，可以为空）
 * 27 year_month_date 时间（年月）
 * 28 approver_duty 职位（值列表选择）
 * 29 approver_title 职务 （手动输入）
 * 30 date_month 时间月份(有默认值，是一个开始时间，结束时间，需校验不能为空，不能夸 12 个月)
 * 31 receipt_type_desc 发票类型（与19重复，前端不处理后端改）
 * 32 receipt_status_desc 发票状态（与20重复，前端不处理后端改）
 * 33 check_result 发票查验结果返回码（与21重复，前端不处理后端改， ）
 * ------------
 * 业务说明：
 * backend_id 可能对应多个上传参数 ,比如报表A,报表B都有一个搜索器 backend_idXXX ,
 * 但是，
 * 报表A搜索的时候，backend_idXXX 对应的查询参数是 ggg,
 * 报表B搜索的时候，backend_idXXX 对应的查询参数是 hhh,
 * 那么就要注意，与后端约定 backend_idXXX 参数的时候，可能对应多个
 * let supportMultipleArr = ['receipt_label_types','reimb_status','inv_check_result','check_result']
 * 其中 参数 'inv_check_result'与'check_result' 只是控制 一个搜索器 inv_check_result
 * -----------
 * 34 drawee 购方名称(直接输入)
 * 35 hotel_order_type 酒店费用报表
 * 36 flight_order_type 机票费用报表 订单类型
 * 37 invoice_tag_list 费用标签
 * 38 form_type_list 效率报表单据类型
 * 39 departure_hot_city 城市(起点) 输入框
 * 40 hot_city 城市(终点) 输入框
 * 41 slave_date_default 时间（有默认值，可以为空）
 * 42 cost_center_code 成本中心 有依赖
 * 43 cost_center_item_code_from 成本中心项代码从
 * 44 cost_center_item_code_to 成本中心项代码到
 * 45 cost_center_item_status 成本中心项状态
 * 46 form_oid_list 差旅申请报表新增筛选器-单据名称
 * 47 manual_input 收款方开户名为手动输入控件
 * 48 repayment_type_list 还款方式
 * 49 repayment_status_list 还款单状态
 * 50 payee_type_list 还款单报表类型
 * 51 borrower 借款方
 * 52 payee_type 借款类型，被借款人依赖，借款人根据此值，可以是人或者供应商
 * 53 year 选择年
 * 53 report_type_add_vendor     带消费商（公司支付）的报销单类型 有依赖账套  部门费用类型汇总趋势表 员工费用类型汇总趋势表
 * 54 report_status_add_vendor   带消费商（公司支付）的报销单状态 部门费用类型汇总趋势表 员工费用类型汇总趋势表
 * 上面已经完成
 * todo 相关值列表接口还未完成
 * expense 费用类型，本次迭代不做，
 * card_type_code 卡券类型
 * */

/*
* 注意
* searchFormArr 第 1，2 元素为开始时间与结束时间，顺序不能变（有默认值要校验为空）
* searchFormArr 第 3，4 为开始时间月份与结束时间月份，顺序不能变
* searchFormArr 第 5，6 元素为开始时间与结束时间，顺序不能变（有默认值不校验为空）
* searchFormArr 中每一个元素，代表一个搜索组件，其中id,label都是由后端返回值，进行显示
* */
let searchFormArr = [
  //XX时间从
  {
    type: 'date',
    backend_id: "date",
    defaultValue: currentTimeBeforeThree,
    id: 'startTime',//根据后端赋值，这是写默认的会重新覆盖
    label: messages('data-center.key23'/*从*/)
  },
  //XX时间到
  {
    type: 'date',
    backend_id: "date",
    defaultValue: currentTime,
    id: 'endTime',//根据后端赋值，这是写默认的会重新覆盖
    label: messages('data-center.key24'/*到*/)
  },
  //XX时间从（只是月份）
  {
    type: 'month',
    backend_id: "date_month",
    defaultValue: currentTimeBeforeThree,
    id: 'date_month',//根据后端赋值，这是写默认的会重新覆盖
    label: messages('data-center.key23'/*从*/)
  },
  //XX时间到（只是月份）
  {
    type: 'month',
    backend_id: "date_month",
    defaultValue: currentTime,
    id: 'date_month',//根据后端赋值，这是写默认的会重新覆盖
    label: messages('data-center.key24'/*到*/)
  },
  //XX时间从
  {
    type: 'date',
    backend_id: "slave_date_default",
    defaultValue: currentTimeBeforeThree,
    id: 'startTime',//根据后端赋值，这是写默认的会重新覆盖
    label: messages('data-center.key23'/*从*/)
  },
  //XX时间到
  {
    type: 'date',
    backend_id: "slave_date_default",
    defaultValue: currentTime,
    id: 'endTime',//根据后端赋值，这是写默认的会重新覆盖
    label: messages('data-center.key24'/*到*/)
  },
  //也有到与从，这个会用 date (这种时间组件，也是有开始与结束，但是不校验为空)，时间没有默认值
  {
    type: 'date',
    backend_id: "slave_date",
    id: 'slave_date',//根据后端赋值，这是写默认的会重新覆盖
    label: "时间",//,根据后端赋值，这是写默认的会重新覆盖
  },
  //单个时间组件
  {
    type: 'date',
    backend_id: "single_date",
    defaultValue: undefined,
    id: 'single_date',//根据后端赋值，这是写默认的会重新覆盖
    label: "时间",//,根据后端赋值，这是写默认的会重新覆盖
  },
  //单个时间组件:只显示到年月
  {
    type: 'month',
    backend_id: "year_month_date",
    defaultValue: undefined,
    id: 'year_month_date',//根据后端赋值，这是写默认的会重新覆盖
    label: "年月",//,根据后端赋值，这是写默认的会重新覆盖
  },
  //年(单选)
  {
    single: true,
    type: 'select',
    backend_id: "year",
    defaultValue: (new Date()).getFullYear(),
    id: 'year',//根据后端赋值，这是写默认的会重新覆盖
    label: "年份",//根据后端赋值，这是写默认的会重新覆盖
    options: [],
  },
  // 成本中心项状态
  {
    type: 'radio',
    label: messages('data-center.key93')/*成本中心项状态*/,
    backend_id: "cost_center_item_status",
    id: 'cost_center_item_status',
    defaultValue: 'all',
    options: [
      { label: messages('common.all')/*全部*/, value: 'all' },
      { label: messages('common.valid')/*生效*/, value: 'enable' },
      { label: messages('common.invalid')/*失效*/, value: 'disable' },
    ]
  },
  //城市
  {
    type: 'select',
    id: 'status',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "city",
    label: "城市",//,根据后端赋值，这是写默认的会重新覆盖
    options: popularCityList//需要从后端请求，引用传递
  },
  //发票标签 （多选）
  {
    type: 'multiple',
    id: 'receipt_label_types',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "receipt_label_types",
    label: "发票标签",//,根据后端赋值，这是写默认的会重新覆盖
    options: receiptLabelTypesList//需要从后端请求，引用传递
  },
  //费用是否抵扣：
  {
    single: true,
    type: 'select',
    id: 'is_vat_invoice',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "is_vat_invoice",
    label: "类型",//根据后端赋值，这是写默认的会重新覆盖
    defaultValue: "2",
    options: [
      {
        label: "是",
        value: "1"
      },
      {
        label: "否",
        value: "0"
      },
      {
        label: "全部",
        value: '2'
      },
    ]
  },
  //供应商：
  {
    single: true,
    type: 'select',
    id: 'status',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "source",
    label: "供应商",//根据后端赋值，这是写默认的会重新覆盖
    options: [
      {
        label: messages('data-center.key25'/*滴滴*/),
        value: "滴滴"
      },
      {
        label: messages('data-center.key26'/*神州*/),
        value: "神州"
      },
    ]
  },
  //借款类型：
  {
    single: true,
    type: 'select',
    event: "payee_type",
    id: 'payee_type',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "payee_type_list",
    label: "类型",//根据后端赋值，这是写默认的会重新覆盖
    options: [
      {
        label: "供应商",
        value: "1001"
      },
      {
        label: "员工",
        value: "1002"
      },
    ]
  },

  //部门：上传部门 departmentCode
  {
    single: false,
    type: 'list',
    id: 'departmentOIDs',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "department",
    label: '部门',//根据后端赋值，这是写默认的会重新覆盖
    listType: 'department',
    labelKey: 'name',
    valueKey: 'departmentCode',
    placeholder: messages('data-center.key27'/*请选择*/),
  },
  //账套：上传账套id
  {
    single: true,
    type: 'list',
    id: 'setOfBooks',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "books",
    event: "books",
    label: '账套',//根据后端赋值，这是写默认的会重新覆盖
    listType: 'select_set_of_books',
    labelKey: 'setOfBooksName_functionalCurrencyCode',
    valueKey: 'setOfBooksId',
    placeholder: messages('data-center.key27'/*请选择*/),
  },
  // 法人OID
  {
    single: true,
    type: 'list',
    id: 'companyReceiptedOID',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "legal",
    label: "法人",//根据后端赋值，这是写默认的会重新覆盖
    listType: 'corporation_entity',
    labelKey: 'companyName',
    valueKey: 'companyReceiptedOID',
    placeholder: messages('data-center.key27'/*请选择*/),
  },
  // 公司:OID（老公司就一个，新公司属于集团下面多个公司）
  {
    single: false,
    type: 'list',
    id: 'corporationOIDs',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "company",
    label: messages('data-center.key9'/*公司*/),
    listType: 'enabled_company',
    labelKey: 'name',
    valueKey: 'companyOID',
    placeholder: messages('data-center.key27'/*请选择*/),
  },
  //$# card_type_code
  {
    type: 'multiple',
    id: 'card_type_code',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "card_type_code",
    label: "卡券类型",//根据后端赋值，这是写默认的会重新覆盖
    options: [
      {
        label: messages('expense-parent-report.SQ002_001'/*实体卡券*/),
        value: "001"
      },
      {
        label: messages('expense-parent-report.SQ002_002'/*电子卡券*/),
        value: "002"
      },
    ]
  },
    
  // 驳回人(人员控件)oid
  {
    single: false,
    type: 'list',
    id: 'corporationOIDs',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "rejecter",
    label: "",//根据后端赋值，这是写默认的会重新覆盖
    listType: 'user',
    labelKey: 'fullName',
    valueKey: 'userOID',
    placeholder: messages('data-center.key27'/*请选择*/),
    listExtraParams: { status: 'all' }
  },
  //借款人 有依赖 payee_type
  {
    single: true,
    type: 'list',
    id: 'borrower',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "borrower",
    label: "",//根据后端赋值，这是写默认的会重新覆盖
    listType: 'user',
    labelKey: 'fullName',
    valueKey: 'userOID',
    placeholder: messages('data-center.key27'/*请选择*/),
  },
  // 差旅申请报表新增筛选器- 单据名称  这里是差旅单 2001 加 其他单 4100
  {
    type: 'select',
    id: 'form_oid_list',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "form_oid_list",
    label: "单据名称",//根据后端赋值，这是写默认的会重新覆盖
    options: formTypeList,//需要从后端请求，引用传递
    placeholder: messages('data-center.key27'/*请选择*/),
  },
  // 申请单明细报表  这里是差旅单 2001 加 费用单2002
  {
    type: 'select',
    id: 'tr_ea_form_oid_list',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "tr_ea_form_oid_list",
    label: "单据名称",//根据后端赋值，这是写默认的会重新覆盖
    options: formTypeListResuqest,//需要从后端请求，引用传递
    placeholder: messages('data-center.key27'/*请选择*/),
  },
  // 驳回节点
  {
    type: 'select',
    id: 'rejectnode',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "rejectnode",
    label: "驳回节点",//根据后端赋值，这是写默认的会重新覆盖
    options: rejectCodeList,//需要从后端请求，引用传递
    placeholder: messages('data-center.key27'/*请选择*/),
  },
  // 币种列表
  {
    type: 'select',
    id: 'currency',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "currency",
    label: "币种",//根据后端赋值，这是写默认的会重新覆盖
    options: currencyTypeList,//需要从后端请求，引用传递
    placeholder: messages('data-center.key27'/*请选择*/),
  },
  // 还款单报表 类型
  // {
  //   type: 'select',
  //   id: 'payee_type_list',//根据后端赋值，这是写默认的会重新覆盖
  //   backend_id: "payee_type_list",
  //   label: "类型",//根据后端赋值，这是写默认的会重新覆盖
  //   options: payeeTypeList,//需要从后端请求，引用传递
  //   placeholder: messages('data-center.key27'/*请选择*/),
  // },
  // 还款方式
  {
    type: 'select',
    id: 'repayment_type_list',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "repayment_type_list",
    label: "还款方式",//根据后端赋值，这是写默认的会重新覆盖
    options: repaymentTypeList,//需要从后端请求，引用传递
    placeholder: messages('data-center.key27'/*请选择*/),
  },

  // 还款单状态
  {
    type: 'select',
    id: 'repayment_status_list',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "repayment_status_list",
    label: "还款单状态",//根据后端赋值，这是写默认的会重新覆盖
    options: repaymentStatusList,//需要从后端请求，引用传递
    placeholder: messages('data-center.key27'/*请选择*/),
  },

  // 单据类型
  {
    type: 'select',
    id: 'invoice',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "invoice",
    label: "单据类型",//根据后端赋值，这是写默认的会重新覆盖
    options: invoiceTypeList,//需要从后端请求，引用传递
    placeholder: messages('data-center.key27'/*请选择*/),
  },
  //效率报表单据类型
  {
    type: 'select',
    id: 'form_type_list',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "form_type_list",
    label: "效率报表单据类型",//根据后端赋值，这是写默认的会重新覆盖
    options: effInvoiceTypeList,//需要从后端请求，引用传递
    placeholder: messages('data-center.key27'/*请选择*/),
  },
  //报销单状态
  {
    type: 'multiple',
    id: 'reimb_status',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "reimb_status",
    label: "状态（报销单状态）",//根据后端赋值，这是写默认的会重新覆盖
    options: invoiceStatusList,//需要从后端请求，引用传递
    placeholder: messages('data-center.key27'/*请选择*/),
  },
  //报销单状态 带消费商（公司支付）的报销单状态
  {
    type: 'multiple',
    id: 'report_status_add_vendor',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "report_status_add_vendor",
    label: "状态（报销单状态）",//根据后端赋值，这是写默认的会重新覆盖
    options: invoiceStatusListAddVendorList,//需要从后端请求，引用传递
    placeholder: messages('data-center.key27'/*请选择*/),
  },
  //借款单状态
  {
    type: 'select',
    id: 'loan_status',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "loan_status",
    label: "状态（借款单状态）",//根据后端赋值，这是写默认的会重新覆盖
    options: loanStatusList,//需要从后端请求，引用传递
    placeholder: messages('data-center.key27'/*请选择*/),
  },
  //申请单状态
  {
    type: 'select',
    id: 'app_status',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "app_status",
    label: "状态（报销单状态）",//根据后端赋值，这是写默认的会重新覆盖
    options: appStatusList,//需要从后端请求，引用传递
    placeholder: messages('data-center.key27'/*请选择*/),
  },
  //报销单单据类型
  {
    type: 'select',
    id: 'reimbursement_type',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "reimbursement_type",
    label: "报销单单据类型",//根据后端赋值，这是写默认的会重新覆盖
    options: reimbDocTypeList,//需要从后端请求，引用传递
    placeholder: messages('data-center.key27'/*请选择*/),
  },
  //申请单单据类型
  {
    type: 'select',
    id: 'application_type',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "application_type",
    label: "申请单单据类型",//根据后端赋值，这是写默认的会重新覆盖
    options: applicationDocTypeList,//需要从后端请求，引用传递
    placeholder: messages('data-center.key27'/*请选择*/),
  },
  //申请单单据类型 不包含借款单
  {
    type: 'select',
    id: 'ta_ea_application_type',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "ta_ea_application_type",
    label: "申请单单据类型",//根据后端赋值，这是写默认的会重新覆盖
    options: applicationDocTypeList2,//需要从后端请求，引用传递
    placeholder: messages('data-center.key27'/*请选择*/),
  },
  //行程类型
  {
    type: 'select',
    id: 'trip',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "trip",
    label: "行程类型",//根据后端赋值，这是写默认的会重新覆盖
    options: tripTypeList,//需要从后端请求，引用传递
    placeholder: messages('data-center.key27'/*请选择*/),
  },
  //发票类型
  {
    type: 'multiple',
    id: 'inv_type',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "inv_type",
    label: "发票类型",//根据后端赋值，这是写默认的会重新覆盖
    options: invTypeList,//需要从后端请求，引用传递
    placeholder: messages('data-center.key27'/*请选择*/),
  },
  //发票状态
  {
    type: 'select',
    id: 'inv_status',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "inv_status",
    label: "发票状态",//根据后端赋值，这是写默认的会重新覆盖
    options: invStatusList,//需要从后端请求，引用传递
    placeholder: messages('data-center.key27'/*请选择*/),
  },
  //发票检验结果
  {
    type: 'multiple',
    id: 'inv_check_result',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "inv_check_result",
    label: "发票检验结果",//根据后端赋值，这是写默认的会重新覆盖
    options: invCheckResultList,//需要从后端请求，引用传递
    placeholder: messages('data-center.key27'/*请选择*/),
  },
  //是否合规
  {
    type: 'select',
    id: 'compliant',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "compliant",
    label: "是否合规",//,根据后端赋值，这是写默认的会重新覆盖
    options: isLowOkList//需要从后端请求，引用传递
  },
  //商务卡状态
  {
    type: 'select',
    id: 'corp_card_status',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "corp_card_status",
    label: "商务卡状态",//,根据后端赋值，这是写默认的会重新覆盖
    options: corpCardStatusList//需要从后端请求，引用传递
  },
  // 驳回人(人员控件)oid
  {
    single: true,
    type: 'list',
    id: 'act_nam',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "act_nam",
    label: "",//根据后端赋值，这是写默认的会重新覆盖
    listType: 'user',
    labelKey: 'fullName',
    valueKey: 'userOID',
    placeholder: messages('data-center.key27'/*请选择*/),
  },
  //收款方开户名为手动输入控件，code = manual_input.
  {
    type: 'input',
    id: 'manual_input',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "manual_input",
    label: "收款方开户名",//,根据后端赋值，这是写默认的会重新覆盖
  },
  //职位 手动输入  approver_title
  {
    type: 'input',
    id: 'approver_title',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "approver_title",
    label: "职位",//,根据后端赋值，这是写默认的会重新覆盖
  },
  //职务 选择值列表 approver_duty
  {
    single: true,
    type: 'list',
    id: 'approver_duty',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "approver_duty",
    label: "职务",//根据后端赋值，这是写默认的会重新覆盖
    listType: 'personDutyModel',
    labelKey: 'messageKey',
    valueKey: 'value',
    listExtraParams: { systemCustomEnumerationType: "1002" },
    placeholder: messages('data-center.key27'/*请选择*/),
  },
  //成本中心项编码从
  {
    type: 'input',
    id: 'cost_center_item_code_from',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "cost_center_item_code_from",
    label: "成本中心项编码从",//,根据后端赋值，这是写默认的会重新覆盖
  },
  // 成本中心项编码到
  {
    type: 'input',
    id: 'cost_center_item_code_to',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "cost_center_item_code_to",
    label: "成本中心项编码到",//,根据后端赋值，这是写默认的会重新覆盖
  },
  //购方名称 手动输入  drawee
  {
    type: 'input',
    id: 'drawee',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "drawee",
    label: "购方名称",//,根据后端赋值，这是写默认的会重新覆盖
  },
  //酒店费用报表
  {
    type: 'select',
    id: 'hotel_order_type',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "hotel_order_type",
    label: "酒店费用报表",//,根据后端赋值，这是写默认的会重新覆盖
    options: hotelOrderTypeList//需要从后端请求，引用传递
  },
  //机票费用报表
  {
    type: 'select',
    id: 'flight_order_type',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "flight_order_type",
    label: "机票费用报表",//,根据后端赋值，这是写默认的会重新覆盖
    options: flightOrderTypeList//需要从后端请求，引用传递
  },
  {
    type: 'select',
    id: 'invoice_tag_list',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "invoice_tag_list",
    label: "费用标签",//,根据后端赋值，这是写默认的会重新覆盖
    options: invoiceTagList//需要从后端请求，引用传递
  },
  //城市(起点)
  {
    type: 'input',
    id: 'departure_hot_city',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "departure_hot_city",
    label: "入住城市",//,根据后端赋值，这是写默认的会重新覆盖
  },
  //城市(终点)
  {
    type: 'input',
    id: 'hot_city',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "hot_city",
    label: "入住城市",//,根据后端赋值，这是写默认的会重新覆盖
  },
  // 预定人(人员控件)oid
  {
    single: true,
    type: 'list',
    id: 'user_oid',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "user_oid",
    label: "",//根据后端赋值，这是写默认的会重新覆盖
    listType: 'user',
    labelKey: 'fullName',
    valueKey: 'userOID',
    placeholder: messages('data-center.key27'/*请选择*/),
  },
  //单据号 手动输入  business_code
  {
    type: 'input',
    id: 'business_code',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "business_code",
    label: "单据号",//根据后端赋值，这是写默认的会重新覆盖
  },
  // 单据标签
  {
    type: 'multiple',
    id: 'label_code',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "form_label_list",
    label: "单据标签",//根据后端赋值，这是写默认的会重新覆盖
    options: docLabelsList,//需要从后端请求，引用传递
    placeholder: messages('data-center.key27'/*请选择*/),
  },
  // 收单状态
  {
    type: 'select',
    id: 'receive_status',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "receipt_status",
    label: "收单状态",//根据后端赋值，这是写默认的会重新覆盖
    options: receiptStatusList,//需要从后端请求，引用传递
    placeholder: messages('data-center.key27'/*请选择*/),
  },
  // 收单日期
  {
    type: 'dateRange',
    backend_id: "receipt_date",
    id: 'receive_date',//根据后端赋值，这是写默认的会重新覆盖
    label: "收单日期",//,根据后端赋值，这是写默认的会重新覆盖
  },
  // 开票费用发生日期 或 开票日期 或 报销单提交日期
  {
    type: 'dateRange',
    backend_id: "expense_create_date",
    id: 'expense_created_date',//根据后端赋值，这是写默认的会重新覆盖
    label: "费用发生日期",//,根据后端赋值，这是写默认的会重新覆盖
  },
  // 单据类型
  {
    type: 'searcher',
    id: 'form_name',
    backend_id: "form_name_list",
    label: "单据类型",//根据后端赋值，这是写默认的会重新覆盖
    listType: 'authority_form',
    descriptionKey: 'companyName',
    labelKey: 'formName',
    valueKey: 'formOID',
    listExtraParams: { formType: 1002 }
  },
  // 单据类型(借款单)
  {
    type: 'searcher',
    id: 'form_name',
    backend_id: "loan_form_name_list",
    label: "单据类型",//根据后端赋值，这是写默认的会重新覆盖
    listType: 'authority_form',
    descriptionKey: 'companyName',
    labelKey: 'formName',
    valueKey: 'formName',
    listExtraParams: { formType: 3001 }
  },
  // 发票号码
  {
    type: 'input',
    id: 'billing_no',
    backend_id: "receipt_num",
    label: "发票号码",//根据后端赋值，这是写默认的会重新覆盖
  },  // 发票号码
  {
    type: 'input',
    id: 'billing_code',
    backend_id: "receipt_code",
    label: "发票号码",//根据后端赋值，这是写默认的会重新覆盖
  },
  //支付方式
  {
    type: 'select',
    id: 'payment_type',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "payment_type",
    label: "支付方式",//根据后端赋值，这是写默认的会重新覆盖
    options: paymentTypeList,//需要从后端请求，引用传递
    placeholder: messages('data-center.key27'/*请选择*/),
  },
  //订单号 手动输入  order_no
  {
    type: 'input',
    id: 'order_no',//根据后端赋值，这是写默认的会重新覆盖
    backend_id: "order_no",
    label: "订单号",//根据后端赋值，这是写默认的会重新覆盖
  },

];
export default {
  /**
   * 根据后端返回的 reportCriteriaDTOList，或者 reportCriteriaCustomizedDTOList ，获取前端的组件
   * @param arr 后端返回的组件
   * @param searchFormArr 前端的组件
   * @param reportId 报表id
   * @returns {Array}
   */
  getSearchForm(arr, searchFormArr, reportId) {
    //每次遇到时间的时候 arr[i].criteriaCode === "date"，就连续添加两个 时间控件
    let newComponentArr = [];
    for (let i = 0; i < arr.length; i++) {
      let _componentArr = _getSearchComponentByCriteriaCode(arr[i], searchFormArr);
      //searchArea 搜索组件排序
      newComponentArr = newComponentArr.concat(_componentArr);
    }
    return newComponentArr;

    function _getSearchComponentByCriteriaCode(item, searchFormArr) {
      //前后端约定的字段类型
      let code = item.criteriaCode;
      //字段显示的title
      let criteriaName = item.criteriaName;
      //上传对应的字段
      let criteriaPropName = item.criteriaPropName;
      //字段序号
      let seqNo = item.criteriaSeqNo;
      let cArr = [];
      for (let j = 0; j < searchFormArr.length; j++) {
        if (code === searchFormArr[j].backend_id) {
          if (code === "date") {
            //如果是date类型，需要返回两个，一个时间从，时间到
            let startTime = deepFullCopy(searchFormArr[0]);
            let endTime = deepFullCopy(searchFormArr[1]);
            cArr = [startTime, endTime];
            //时间的特殊处理
            cArr[0].seqNo = seqNo;
            cArr[0].id = criteriaPropName + "_$$_start_time";
            cArr[0].label = criteriaName + "(" + cArr[0].label + ")";
            cArr[1].seqNo = seqNo;
            cArr[1].id = criteriaPropName + "_$$_end_time";
            cArr[1].label = criteriaName + "(" + cArr[1].label + ")";
            return cArr;
          } else if (code === "slave_date") {
            //如果是 slave_date 类型，需要返回两个，一个时间从，时间到
            //这种与 date 的区别是可以为空
            let startTime = deepFullCopy(searchFormArr[0]);
            let endTime = deepFullCopy(searchFormArr[1]);
            cArr = [startTime, endTime];
            //时间的特殊处理
            cArr[0].seqNo = seqNo;
            cArr[0].id = criteriaPropName + "_$_$_start_time";
            cArr[0].label = criteriaName + "(" + cArr[0].label + ")";
            cArr[0].defaultValue = undefined;
            cArr[0].backend_id = 'slave_date';
            cArr[1].seqNo = seqNo;
            cArr[1].id = criteriaPropName + "_$_$_end_time";
            cArr[1].label = criteriaName + "(" + cArr[1].label + ")";
            cArr[1].defaultValue = undefined;
            cArr[1].backend_id = 'slave_date';
            return cArr;
          } else if (code === "slave_date_default") {
            //如果是 slave_date_default 类型，需要返回两个，一个时间从，时间到
            //这种与 slave_date 的区别是有默认值
            let startTime = deepFullCopy(searchFormArr[4]);
            let endTime = deepFullCopy(searchFormArr[5]);
            cArr = [startTime, endTime];
            //时间的特殊处理
            cArr[0].seqNo = seqNo;
            cArr[0].id = criteriaPropName + "_$_$_start_time";
            cArr[0].label = criteriaName + "(" + cArr[0].label + ")";
            cArr[1].seqNo = seqNo;
            cArr[1].id = criteriaPropName + "_$_$_end_time";
            cArr[1].label = criteriaName + "(" + cArr[1].label + ")";
            return cArr;
          } else if (code === "date_month") {
            //如果是 date_month 类型，需要返回两个，一个时间从，时间到
            //这种与 date 的区别是显示为月份
            //目前是只有 id 为 12 的报表才有这种组件
            let startTime = deepFullCopy(searchFormArr[2]);
            let endTime = deepFullCopy(searchFormArr[3]);
            cArr = [startTime, endTime];
            //时间的特殊处理
            cArr[0].seqNo = seqNo;
            cArr[0].id = criteriaPropName + "_$$_start_time";
            cArr[0].label = criteriaName + "(" + cArr[0].label + ")";
            cArr[1].seqNo = seqNo;
            cArr[1].id = criteriaPropName + "_$$_end_time";
            cArr[1].label = criteriaName + "(" + cArr[1].label + ")";
            return cArr;
          }

          let cache = deepFullCopy(searchFormArr[j]);
          //criteriaPropName代表前端像后端传的值
          cache.id = criteriaPropName;
          cache.label = criteriaName;
          cArr = [cache];
          cArr[0].seqNo = seqNo;
          if (code === "expense_create_date" && criteriaPropName === 'receipt_date' && Number(reportId) === 15) { // 发票汇总报表开票日期有默认值
            cArr[0].defaultValue = [currentTimeBeforeThree, currentTime];
          }
          return cArr
        }
      }
    }
  },
  //根据后端返回的 reportColumnDTOList，或者 reportColumnCustomizedDTOList ，获取报表的列
  getReportTableColumn(arr, callBack) {
    let newArr = [];
    for (let i = 0; i < arr.length; i++) {
      let item = arr[i];
      if (!item.hide) {
        item.title =
          <Tooltip placement="topLeft" title={item.columnDisplayName}>{item.columnDisplayName}</Tooltip>;
        item.dataIndex = `${item.columnPropName}`;
        item.render = (text) => {
          let realText = typeof text === 'string' ? text.replace(/\\n/gm,"<br/>") : text;
          const content = text ?
            <Tooltip title={<div dangerouslySetInnerHTML={{ __html: realText }}></div>}
                    placement={'topLeft'}>
              <div dangerouslySetInnerHTML={{ __html: realText }}></div>
            </Tooltip> : '-';
          return <div
            onClick={() => callBack(item)}
            style={{ whiteSpace: 'pre-wrap' }}
          >{content}</div>;
        }
        if (item.children && item.children.length > 0) {
          let arr = [];
          item.children.map(a => {
            arr.push({
              title: <Tooltip placement="topLeft" title={a.columnDisplayName}>{a.columnDisplayName}</Tooltip>,
              dataIndex: `${a.columnPropName}`,
              render: (data, record) => {
                const txt = data || data === 0 ? <Tooltip title={data}
                      placement={'topLeft'}>
                  {data}
                </Tooltip> : '-';
                return <div
                >{txt}</div>;
              },
              width: 200,
              children: a.children && a.children.length > 0 ? this.getList(a.children, item.columnPropName, a.columnPropName) : undefined
            })
          });
          item.children = arr;
        }
        item.width = 200;
        newArr.push(item)
      }
    }
    //返回结果样例
    // let co = [
    //   {
    //     title: "列名1",
    //     key: "companyName",
    //     dataIndex: 'companyName',
    //   },
    //   {
    //     title: "列名2",
    //     key: "employeeID",
    //     dataIndex: 'employeeID',
    //   },
    // ]
    return newArr
  },
  //获取查询参数
  getParams(arr, reportId) {
    let params = {};
    for (let i = 0; i < arr.length; i++) {
      params[arr[i].criteriaPropName] = "";
    }
    //返回结果样例:每一个key对于的一个查询条件
    // {
    //   "keyword": "",
    //   "departmentOIDs":  "",
    //   "corporationOIDs":  "",
    //   "status": "all"
    // },
    for (let key in params) {
      params[key] = undefined;
      if (key === 'set_of_books_id') {
        params[key] = (this.setBooksValue()).setOfBooksId
      }
      if (key === 'YEAR') {
        params[key] = (new Date()).getFullYear()
      }
      if (Number(reportId) === 15 && key === 'receipt_date') {
        params[key] = [currentTimeBeforeThree, currentTime]
      }
    }
    return params
  },
  dataColumnsByMan(arr) {
    let newArr = [];
    for (let i = 0; i < arr.length; i++) {
      arr[i].editName = false;
      arr[i].editHide = false;
      newArr.push(arr[i])
    }
    return newArr
  },
  // 获取报表结构
  getReportDetail(reportId, searchParams, callBack) {
    let param = {
      id: reportId,//报表id
    };
    if (searchParams && (parseInt(reportId) === 53 || parseInt(reportId) === 52)) {
      if (searchParams.date && searchParams.date !== 'Invalid date') {
        param.date = searchParams.date;
      }
    }
    return new Promise((resolve, reject) => {
      httpFetch.get(config.baseUrl + '/report/api/report/getReport', param)
        .then((res) => {
          let data = res.data;
          //data字段解释
          //reportCriteriaDTOList  是顶部查询字段
          //reportCriteriaCustomizedDTOList 有就显示自定义的是自定义查询字段，有就显示自定义的

          //reportColumnDTOList 是报表的列
          //reportColumnCustomizedDTOList是自定义的列，有就显示自定义的

          let search = data.reportCriteriaDTOList;//默认搜索组件
          let customSearch = data.reportCriteriaCustomizedDTOList;//自定义组件

          let column = data.reportColumnDTOList;//默认报表列
          let customColumn = data.reportColumnCustomizedDTOList;//自定义报表列

          let _reportSearch = customSearch.length > 0 ? customSearch : search;
          let reportColumn = customColumn.length > 0 ? customColumn : column;

          //有些搜索字段是有依赖关系，把依赖关系的字段挑选出来
          let dFields = this.divideDependecyFields(_reportSearch);
          let reportSearch = dFields.arrNoD;
          let reportSearchDependecy = dFields.arrD;

          data.searchFormByMan = this.getSearchForm(reportSearch, searchFormArr, reportId);
          data.setColumnByMan = this.getReportTableColumn(reportColumn, callBack);
          data.paramsByMan = this.getParams(reportSearch, reportId);
          data.dataColumnsByMan = this.dataColumnsByMan(reportColumn);

          //获取额外的搜索字段
          //目前只考虑成本中心 费用类型
          if (reportSearchDependecy.length > 0) {
            data.extraFieldsSearchArea = reportSearchDependecy;
          } else {
            data.extraFieldsSearchArea = [];
          }

          resolve(res)
        })
        .catch(function (err) {
          errorMessage(err.response);
          reject(err.response);
        })
    })
  },
  //分离有依赖的字段，与没有依赖的字段
  //比如成本中心字段，依赖于账套的查询，就需要把成本中心单独分离出来
  divideDependecyFields(reportSearch) {
    let arrD = [];
    let arrNoD = [];
    reportSearch.map((item) => {
      //成本中心项，费用类别 有依赖
      // dependecyCriteriaCode 目前只有依赖 books
      // 借款单报表 借款方，依赖借款类型
      if (item["dependecyCriteriaCode"]) {
        arrD.push(item);
      } else {
        arrNoD.push(item);
      }
    });
    return {
      arrD,
      arrNoD
    };
  },
  //寻找有依赖的字段
  findRightDependecyField(item, arr) {
    for (let i = 0, len = arr.length; i < len; i++) {
      if (item.criteriaCode === arr[i].backend_id) {
        return arr[i];
      }
    }
  },
  //查询报表数据
  getTravelDataList(body) {
    // let body = {
    //   id: "",//报表id
    //   page: "",
    //   size: "",
    //   "startTime":"2016-11-01T12:37:47Z",
    //   "endTime":"2016-11-08T12:37:47Z",
    //   "criteria":{
    //     "set_of_books_id":"948201345251287041"
    //    }
    //   }
    return new Promise((resolve, reject) => {
      httpFetch.post(config.baseUrl + '/report/api/report/search', body)
        .then((response) => {
          // fix bug28893
          response.data = response.data.filter(item => {
            if (item + "" !== "null" && item + "" !== "undefined") {
              return item;
            }
          })
          resolve(response)
        })
        .catch(function (err) {
          errorMessage(err.response);
          reject(err.response);
        })
    })
  },
  //获取 审批流程平均时长
  getApproverTime(body) {
    // let body = {
    //   id: "",//报表id
    //   page: "",
    //   size: "",
    //   "startTime":"2016-11-01T12:37:47Z",
    //   "endTime":"2016-11-08T12:37:47Z",
    //   "criteria":{
    //     "set_of_books_id":"948201345251287041"
    //    }
    //   }
    return new Promise((resolve, reject) => {
      httpFetch.post(config.baseUrl + '/report/api/report/apprEfficiency/control', body)
        .then((response) => {
          resolve(response)
        })
        .catch(function (err) {
          errorMessage(err.response);
          reject(err.response);
        })
    })
  },
  //获取 待审批单据数量 & 平均待审批时长
  getWaitingTime(body) {
    return new Promise((resolve, reject) => {
      httpFetch.post(config.baseUrl + '/report/api/report/apprTodoEfficiency/control', body)
        .then((response) => {
          resolve(response)
        })
        .catch(function (err) {
          errorMessage(err.response);
          reject(err.response);
        });
    });
  },
  //获取账套的默认值
  getBooksDefaultValueById(backend_id, searchForm) {
    let val = [{}];
    searchForm.map(item => {
      if (item.backend_id === backend_id) {
        val = item.defaultValue
      }
    });
    return val
  },
  //设置年的初始化值
  setYearValue() {
    return (function (year) {
      let tenantFromFeeReport = configureStore.store.getState().login.tenant;
      let startTime = (new Date(tenantFromFeeReport.createdDate)).getFullYear();
      let len = year - startTime + 1;
      if (len + "" === "NaN") {
        len = 20;
      }
      return (new Array(len)).fill(1).map((item, index) => {
        let obj = {
          value: year - index,
          label: year - index
        };
        return obj
      })
    })((new Date()).getFullYear())
  },
  //是否需要
  isNeedBooksRequest(data) {
    return data.reportCriteriaDTOList.filter(item => item.criteriaCode === 'books').length > 0;
  },
  //设置账套的默认值
  setBooksValue() {
    let companyFromFeeReport = configureStore.store.getState().login.company;
    let obj = {
      setOfBooksName_functionalCurrencyCode: companyFromFeeReport.setOfBooksName + "/" + companyFromFeeReport.baseCurrency,
      setOfBooksId: companyFromFeeReport.setOfBooksId
    }
    return obj;
  },
  //初始化搜索组件数据
  InitSearchComponents(langCode) {
    searchFormArr.map(item => {
      if (item.backend_id === "year") {
        item.options = this.setYearValue()
      }
      if (item.backend_id === "books") {
        item.defaultValue = [this.setBooksValue()]
      }
    });
    return Promise.all([
      //报销单状态
      RSCService.getValue5002(invoiceStatusList, invoiceStatusListAddVendorList),
      //发票检验结果
      RSCService.getValueListCommon(5003, invCheckResultList),
      //驳回节点
      RSCService.getValueListCommon(5004, rejectCodeList),
      //发票状态
      RSCService.getValueListCommon(5005, invStatusList),
      //单据类型
      RSCService.getValueListCommon(5006, invoiceTypeList),
      //报销单单据类型
      RSCService.getValueListCommon(5007, reimbDocTypeList),
      //申请单单据类型
      RSCService.getValueListCommon(5008, applicationDocTypeList),
      //申请单单据类型
      RSCService.getValueListCommon(5042, applicationDocTypeList2),
      //行程类型
      RSCService.getValueListCommon(5009, tripTypeList),
      //申请单状态
      RSCService.getValueListCommon(5010, appStatusList),
      //支付方式列表
      RSCService.getValueListCommon(5032, paymentTypeList),
      //借款单状态
      RSCService.getValueListCommon(5011, loanStatusList),
      //发票类型
      RSCService.getValueListCommon(1012, invTypeList),
      //bool类型的都可以用
      //是否合规
      RSCService.getValueListCommon(5013, isLowOkList),
      //商务卡状态
      RSCService.getValueListCommon(5014, corpCardStatusList),
      //机票费用报表 订单类型
      RSCService.getValueListCommon(5020, flightOrderTypeList),
      //酒店费用报表 订单类型
      RSCService.getValueListCommon(5021, hotelOrderTypeList),
      //费用标签
      RSCService.getValueListCommon(5023, invoiceTagList),
      //效率报表单据类型
      RSCService.getValueListCommon(5024, effInvoiceTypeList),
      //还款单状态(type=5025)
      RSCService.getValueListCommon(5025, repaymentStatusList),
      //还款方式(type=5026)
      RSCService.getValueListCommon(5026, repaymentTypeList),
      //还款类型(type=5027)
      RSCService.getValueListCommon(5027, payeeTypeList),
      //币种列表
      RSCService.getValueCurrency(currencyTypeList),
      //差旅申请报表新增筛选器-单据名称
      RSCService.getformTypeList(formTypeList, { formTypeList: "2001,4100" }),
      //申请明细报表新增筛选器-单据名称
      RSCService.getformTypeList(formTypeListResuqest, { formTypeList: "2001,2002" }),
      //热门城市
      RSCService.getPopularCity(langCode, popularCityList),
      //发票标签
      RSCService.getReceiptLabelTypes(receiptLabelTypesList),
      // 单据标签
      RSCService.getDocLabels(docLabelsList),
      // 收单状态
      RSCService.getValueListCommon(5031, receiptStatusList)
    ])
  },
  //转换 params 中的年月格式
  tansYearMonth(params, searchForm) {
    // "year_month_date"
    searchForm.map(item => {
      if (item.backend_id === "year_month_date") {
        if (params[item.id]) {
          if (params[item.id] === "Invalid date") {
            params[item.id] = undefined;
          } else {
            let a = params[item.id].split("-");
            params[item.id] = a[0] + "-" + a[1];
          }
        }
      }
    });
    return params;
  },
  //依次检测时间字段，查询时间跨度不能超过12个月
  checkDateValueGap(checkArr, val) {
    if (checkArr.length > 0) {
      for (let i = 0; i < checkArr.length; i++) {
        let keyS = checkArr[i] + "_$$_start_time";
        let keyE = checkArr[i] + "_$$_end_time";
        let sy = moment(val[keyS]).get("year");
        let ey = moment(val[keyE]).get("year");
        let sm = moment(val[keyS]).get("month");
        let em = moment(val[keyE]).get("month");
        if ((ey * 12 + em) - (sy * 12 + sm) > 12) {
          return true
        }
      }
      return false
    } else {
      return false
    }
  },
  checkDateDuration(startDate, endDate) {
    if (!startDate || !endDate) return true;
    startDate = moment(startDate);
    endDate = moment(endDate);
    let startYear = startDate.get("year"),
      startMonth = startDate.get("month"),
      endYear = endDate.get("year"),
      endMonth = endDate.get("month");
    return (endYear * 12 + endMonth) - (startYear * 12 + startMonth) > 12
  },
  //依次检测时间字段，开始时间是否大于结束时间
  checkDateValueStartEndSlave(checkArr, val) {
    if (checkArr.length > 0) {
      for (let i = 0; i < checkArr.length; i++) {
        let keyS = checkArr[i] + "_$_$_start_time", keyE = checkArr[i] + "_$_$_end_time";
        val[keyS] = val[keyS] ? moment(val[keyS]).format("YYYY-MM-DD") : null;
        val[keyE] = val[keyE] ? moment(val[keyE]).format("YYYY-MM-DD") : null;
        let stVal = moment(val[keyS]).valueOf(), etVal = moment(val[keyE]).valueOf();
        if (stVal > etVal) {
          return true
        }
      }
      return false
    } else {
      return false
    }
  },
  //依次检测时间字段，开始时间是否大于结束时间
  checkDateValueStartEnd(checkArr, val) {
    if (checkArr.length > 0) {
      for (let i = 0; i < checkArr.length; i++) {
        let keyS = checkArr[i] + "_$$_start_time", keyE = checkArr[i] + "_$$_end_time";
        val[keyS] = val[keyS] ? moment(val[keyS]).format("YYYY-MM-DD") : null;
        val[keyE] = val[keyE] ? moment(val[keyE]).format("YYYY-MM-DD") : null;
        let stVal = moment(val[keyS]).valueOf(), etVal = moment(val[keyE]).valueOf();
        if (stVal > etVal) {
          return true
        }
      }
      return false
    } else {
      return false
    }
  },
  //依次检测时间字段，是否为空
  checkDateValueIsNull(checkArr, val) {
    if (checkArr.length > 0) {
      for (let i = 0; i < checkArr.length; i++) {
        let keyS = checkArr[i] + "_$$_start_time", keyE = checkArr[i] + "_$$_end_time";
        if (val[keyS] === undefined || val[keyE] === undefined ||
          val[keyS] === null || val[keyE] === null ||
          val[keyS] === "" || val[keyE] === "") {
          return true
        }
      }
      return false
    } else {
      return false
    }
  },
  //获取 从时间类型
  getNeedCheckFieldsSlave(fields) {
    let arr = [];
    for (let key in fields) {
      let a = key.split("_$_$_");
      if (a[1] === "start_time") {
        arr.push(a[0])
      }
    }
    return arr;
  },
  //获取时间类型
  getNeedCheckFields(fields) {
    let arr = [];
    for (let key in fields) {
      let a = key.split("_$$_");
      if (a[1] === "start_time") {
        arr.push(a[0])
      }
    }
    return arr;
  },
  //设置默认时间
  setDefaultTime(searchForm) {
    let params = {};
    searchForm.map(item => {
      if (item.id && item.id.indexOf("_$_$_") > 0) {
        let a = item.id.split("_$_$_");
        delete params[a[0]];
        params[item.id] = item.defaultValue;
      }
      if (item.id && item.id.indexOf("_$$_") > 0) {
        let a = item.id.split("_$$_");
        delete params[a[0]];
        params[item.id] = item.defaultValue;
      }
    })
    return params;
  },
  //把多个成对的时候，转换为一个时间字段，以数组方式保存到对象
  transDateToArr(v, searchForm, dateFields, fieldsSalve) {
    let obj = {},
      formatStr = searchForm[0].backend_id === "date_month" ? "YYYY-MM" : "YYYY-MM-DD";

    // 不要问我为什么两遍循环，我也不知道，原作者不是我
    for (let key in v) {
      let a = key.split("_$$_");
      if (_hasInArr(a[0], dateFields)) {
        if (obj[a[0]]) {
          obj[a[0]].push(!!v[key]?moment(v[key]).format(formatStr): "");
          obj[a[0]] = JSON.stringify(obj[a[0]]);
        } else {
          obj[a[0]] = [!!v[key]?moment(v[key]).format(formatStr):""]
        }
      } else {
        if (key.indexOf("_$_$_") > 0) {
          //有这种符号的不要添加是 从时间，
        } else {
          if (typeof v[key] === "object") {
            obj[key] = moment(v[key]).format("YYYY-MM-DD")
          } else {
            obj[key] = v[key];
          }
        }
      }
    }

    for (let key in v) {
      let a = key.split("_$_$_");
      if (_hasInArr(a[0], fieldsSalve)) {
        if (obj[a[0]]) {
          if (moment(v[key]).format("YYYY-MM-DD") === "Invalid date") {
            obj[a[0]].push(null);
          } else {
            obj[a[0]].push(moment(v[key]).format("YYYY-MM-DD"));
          }
          obj[a[0]] = JSON.stringify(obj[a[0]]);
        } else {
          if (moment(v[key]).format("YYYY-MM-DD") === "Invalid date") {
            obj[a[0]] = [null]
          } else {
            obj[a[0]] = [moment(v[key]).format("YYYY-MM-DD")]
          }
        }
      }
    }
    return obj;

    function _hasInArr(str, arr) {
      if (arr.length > 0) {
        for (let j = 0; j < arr.length; j++) {
          if (str === arr[j]) {
            return true
          }
        }
        return false
      } else {
        return false;
      }
    }
  },

  getCurrentTime() {
    return { currentTime, currentTimeBeforeThree }
  },
  // 参与人信息列表
  getJoinPersonList(params) {
    return new Promise((resolve, reject) => {
      httpFetch.get(config.baseUrl + '/report/api/busApp/participants', params)
        .then((res) => {
          resolve(res)
        })
        .catch(function (err) {
          errorMessage(err.response);
          reject(err.response);
        })
    })
  },
  // 费用的参与人列表
  getExpensePersonList(params) {
    return new Promise((resolve, reject) => {
      httpFetch.get(config.baseUrl + '/report/api/busApp/invoice/participants', params)
        .then((res) => {
          resolve(res)
        })
        .catch(function (err) {
          errorMessage(err.response);
          reject(err.response);
        })
    })
  },
  getList(data, title1, title2) {
    let list = [];
    data.map(item => {
      list.push({
        title: <Tooltip placement="topLeft" title={item.columnDisplayName}>{item.columnDisplayName}</Tooltip>,
        dataIndex: `${item.columnPropName}`,
        render: (data) => {
          const txt = data || data === 0 ? <Tooltip title={data}
              placement={'topLeft'}>
            {data}
          </Tooltip> : '-';
          return <div
          >{txt}</div>;
        },
        width: 200,
      })
    })
    return list
  },
  // 申请单接收人信息列表
  getSQReceiverList(params) {
    return new Promise((resolve, reject) => {
      httpFetch.get(config.baseUrl + '/report/api/giftApp/giftReceiver', params)
        .then((res) => {
          resolve(res)
        })
        .catch(function (err) {
          errorMessage(err.response);
          reject(err.response);
        })
    })
  },
  // 报销单接收人信息列表
  getBXReceiverList(params) {
    return new Promise((resolve, reject) => {
      httpFetch.get(config.baseUrl + '/report/api/giftApp/expenseReport/receiver', params)
        .then((res) => {
          resolve(res)
        })
        .catch(function (err) {
          errorMessage(err.response);
          reject(err.response);
        })
    })
  },
}

